home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 352_01 / vector.h < prev    next >
C/C++ Source or Header  |  1991-05-08  |  7KB  |  233 lines
  1. // VECTOR.H - a library of C++ routines for manipulating VECTORS
  2. //             which are ordered arrays of real or complex numbers.
  3. #ifndef  VECTOR_H
  4.     #define VECTOR_H
  5.  
  6.  
  7. #include <math.h>
  8. #include <values.h>        // MINFLOAT, MAXFLOAT
  9. #include <complex.h>
  10.  
  11. #ifndef SMALL_VAL
  12.     #define SMALL_VAL  (1e-30)
  13.     #define LARGE_VAL  (1e+30)
  14. #endif
  15.  
  16. #ifndef PI
  17.     #define PI  M_PI
  18. #endif
  19.  
  20.  
  21. class CVector;        // forward reference to confer friend status.
  22. class Matrix;
  23. class CMatrix;
  24.  
  25. class Vector
  26.     {
  27.     private:
  28.         int n;  float *v;
  29.         friend  CVector;
  30.         friend  Matrix;
  31.         friend  CMatrix;
  32.     public:
  33.     Vector(int=0);                    // initialize n elements to zero
  34.  
  35.     Vector(int i, float minval, float maxval)
  36.         {Vector *vptr=new Vector (i); n=i; v=vptr->v; base(minval, maxval); };
  37.  
  38.  
  39.  
  40.  
  41.         
  42.     Vector( Vector& );                // copy Constructor
  43.     ~Vector();
  44.  
  45.     void realloc ( int=0 );            // change size of vector
  46.  
  47.  
  48.     // ways to address components
  49.     float     operator[](int i) { return v[i]; };    // value lookup
  50.             operator float*() { return v; };    // cast to float
  51.             
  52.     float * data()    {return v; };
  53.     int        dim()    { return n; };                // dimension
  54.  
  55.     float   set(int i, float f=0)    { v[i]=f; return f; }    // assign into.
  56.     float   get(int i)                { return v[i]; }
  57.  
  58.  
  59.  
  60.     Vector& operator=(Vector&);     // assign Vector to Vector
  61.     Vector& operator=(float);        // assign float to Vector
  62.  
  63.     Vector& operator+=(float);        // add to Vector... a float
  64.     Vector& operator+=(Vector&);    //                 ... a Vector
  65.  
  66.     Vector& operator*=(float);        // multiply Vector by scalar.
  67.     Vector& operator*=(Vector&);    // form inner product of 2 V's.
  68.  
  69.     Vector& operator-=(float);
  70.     Vector& operator-=(Vector&);
  71.  
  72.     Vector& operator/=(float);        // checks for zero divide.
  73.  
  74.     friend float sum (Vector&,  int=0, int=-1 );
  75.                                     // sum between point1 and point2
  76.                                     // if point2 == -1, sums to end of V.
  77.     friend float norm (Vector&,  int=0, int=-1 );
  78.                                     // norm between point1 and point2
  79.                                     // if point2 == -1, sums to end of V.
  80.  
  81.     Vector& rotate ( int phase );    // rotate phase# of pts to the left, wraps.
  82.                                     // VECROT.CPP
  83.                                     
  84.     Vector& reverse ( void );        // reverse vector in place. VECRVRS.CPP
  85.     
  86.     void base ( float minval,  float maxval );        // fill in linear interp.
  87.                                                     //  VECBASE.CPP
  88.                                                     
  89.  
  90.     void show (char *title);        // VECSHOW.CPP
  91.  
  92.                                                     
  93.     // cross correlation between 2 vectors. results placed in r & t.
  94.     //                    found in VECCORLT.CPP
  95.     friend void correlate ( Vector&, Vector&, float *r, float *t );
  96.  
  97.     };    //  end definition of class Vector.
  98.  
  99.  
  100.         // graphVector () - popup window with graph of vector
  101.         //                     Xbase is used to label the X axis. default is V.n
  102.         //                    Window is auto-centering.
  103.         //                    SOURCE:  VECGRPH.CPP
  104. void  graphVector( Vector&, char *title=NULL, float Xbase= -1, int seg_win=10 );
  105.  
  106. class CVector            // Complex Vectors.
  107.     {
  108.     public:
  109.         int ispolar;
  110.         Vector x;
  111.         Vector y;
  112.  
  113.         void rectify(void);    // make sure all mags are + if polar
  114.                             // ie: if CVector is polar,
  115.                             // flip angles to make mags>0
  116.                             // source: VECZRECT.CPP
  117.  
  118.  
  119.     // source for assignment, addition, multiplication: VECZ.CPP
  120.     
  121.     CVector(int i=0)                    // initialize n elements to zero
  122.         : x(i), y(i) { ispolar=0; };
  123.     CVector( Vector& xv )                // initialize from a real Vector
  124.         : x(xv), y(xv.n) { ispolar =0; };
  125.     
  126.     CVector( CVector& zv )        
  127.         : x(zv.x), y(zv.y)  {ispolar = zv.ispolar;};    // copy constructor.
  128.     
  129.     // construct CVectors with linear interpolation of values.
  130.     CVector ( int i, float minval, float maxval ) 
  131.             : x(i,minval,maxval), y(i) {ispolar=0;};
  132.     CVector ( int i, complex minval, complex maxval ) 
  133.             : x(i,real(minval),real(maxval)), y(i,imag(minval),imag(maxval))
  134.              {ispolar=0;};
  135.     
  136.         // no destructor needed.
  137.         // taken care of by Vector class.
  138.  
  139.  
  140.     void realloc (int i =0)            // change size of Cvector
  141.         { x.realloc(i), y.realloc(i);};
  142.         
  143.     // ways to address components
  144.     complex    operator[](int i) { return complex(x[i],y[i]); };
  145.     int        dim()    { return x.dim(); };                // dimension
  146.     friend  Vector& real ( CVector& vec )    {return  vec.x; };
  147.     friend  Vector& imag ( CVector& vec )    {return  vec.y; };
  148.  
  149.     complex set(int i, complex z)
  150.                   {
  151.                   x.set(i, real(z));
  152.                   y.set(i, imag(z));
  153.                   return z;
  154.                   }
  155.  
  156.     complex set(int i, float rl, float im=0)
  157.                   {
  158.                   x.set(i, rl);
  159.                   y.set(i, im);
  160.                   return complex (rl,im);
  161.                   }
  162.  
  163.     complex get(int i)    { return complex(x[i], y[i] ); }    // like []
  164.  
  165.  
  166.  
  167.  
  168.     CVector& operator=(CVector&);     // assign          CVector to CVector
  169.     CVector& operator=(Vector&);     // assign real     Vector     to CVector
  170.     CVector& operator=(float);        // assign         float     to CVector
  171.     CVector& operator=(complex);    // assign         complex to CVector
  172.  
  173.     CVector& operator+=(float);        // add to CVector... a float
  174.     CVector& operator+=(complex);    // add to CVector... a complex
  175.     CVector& operator+=(Vector&);    //                 ... a Vector
  176.     CVector& operator+=(CVector&);    //                 ... a CVector
  177.  
  178.     CVector& operator*=(float);        // multiply CVector by scalar.
  179.     CVector& operator*=(complex);    // multiply CVector by complex scalar.
  180.     CVector& operator*=(CVector&);    // form inner product of 2 CV's.
  181.     
  182.     CVector& operator-=(float);        // source: VECZSUB.CPP
  183.     CVector& operator-=(complex);
  184.     CVector& operator-=(Vector&);    // subtract real part from CVector.
  185.     CVector& operator-=(CVector&);
  186.  
  187.  
  188.     CVector& operator/=(float);        // source: VECZDIV.CPP
  189.     CVector& operator/=(complex);    // checks for zero divide.
  190.  
  191.     friend complex sum (CVector&,  int=0, int=-1 );
  192.                                     // sum between point1 and point2
  193.                                     // if point2 == -1, sums to end of V.
  194.                                     // source: VECZSUM.CPP
  195.     friend float norm (CVector&,  int=0, int=-1 );
  196.                                     // norm between point1 and point2
  197.                                     // if point2 == -1, sums to end of V.
  198.                                     // source: VECZNORM.CPP
  199.  
  200.     CVector& rotate (int phase)    {x.rotate(phase);y.rotate(phase);return *this;};
  201.     
  202.     CVector& reverse (void) { x.reverse(); y.reverse(); return *this; };
  203.  
  204.  
  205.     // polar 2 rectangular conversions and vice versa.
  206.     // source:  VECPOLAR.CPP, VECRECT.CPP and VECPHCNT.CPP
  207.     void ToPolar ( void );        // angle ranges -PI to PI
  208.     void ToRect  ( void );
  209.     void PhaseCenter ( float new_min_phase = -PI );        // adjust all phases
  210.  
  211.     };   // end of definition of CVector.
  212.  
  213. // conversions for single complex numbers. performed in place    
  214. //     also found in VECPOLAR.CPP, VECRECT.CPP and VECPHCNT.CPP
  215. void ToPolar ( complex& );
  216. void ToRect  ( complex& );
  217. void PhaseCenter ( complex& , float new_min_phase = -PI);    
  218.     
  219.     
  220.  
  221. // extraction of eeg buffered, interleaved data to single channel Vector form.
  222. //         v = this Vector of pre-set size will be filled with eeg data 
  223. //        scan and chan indicated start scan in buffer and channel number to use
  224. //        skip defines number of points to average together 
  225. //                    from eeg buffer for each newly created vector point.
  226. //                    vector is shorter than eeg by factor of skip. 
  227. //        source: EEG2VEC.CPP
  228. void eeg2Vector ( Vector& v,  int scan, int chan, int skip =1 );
  229.  
  230.  
  231.     
  232. #endif         // end of VECTOR_H
  233.